home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Python 1.3.3 / Python 133 SRC / Mac / Modules / list / Listmodule.c < prev    next >
Text File  |  1996-04-12  |  16KB  |  654 lines
  1.  
  2. /* ========================== Module List =========================== */
  3.  
  4. #include "Python.h"
  5.  
  6.  
  7.  
  8. #define SystemSevenOrLater 1
  9.  
  10. #include "macglue.h"
  11. #include <Memory.h>
  12. #include <Dialogs.h>
  13. #include <Menus.h>
  14. #include <Controls.h>
  15.  
  16. extern PyObject *ResObj_New(Handle);
  17. extern int ResObj_Convert(PyObject *, Handle *);
  18. extern PyObject *OptResObj_New(Handle);
  19. extern int OptResObj_Convert(PyObject *, Handle *);
  20.  
  21. extern PyObject *WinObj_New(WindowPtr);
  22. extern int WinObj_Convert(PyObject *, WindowPtr *);
  23. extern PyTypeObject Window_Type;
  24. #define WinObj_Check(x) ((x)->ob_type == &Window_Type)
  25.  
  26. extern PyObject *DlgObj_New(DialogPtr);
  27. extern int DlgObj_Convert(PyObject *, DialogPtr *);
  28. extern PyTypeObject Dialog_Type;
  29. #define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
  30.  
  31. extern PyObject *MenuObj_New(MenuHandle);
  32. extern int MenuObj_Convert(PyObject *, MenuHandle *);
  33.  
  34. extern PyObject *CtlObj_New(ControlHandle);
  35. extern int CtlObj_Convert(PyObject *, ControlHandle *);
  36.  
  37. extern PyObject *GrafObj_New(GrafPtr);
  38. extern int GrafObj_Convert(PyObject *, GrafPtr *);
  39.  
  40. extern PyObject *BMObj_New(BitMapPtr);
  41. extern int BMObj_Convert(PyObject *, BitMapPtr *);
  42.  
  43. extern PyObject *PMObj_New(PixMapHandle);
  44. extern int PMObj_Convert(PyObject *, PixMapHandle *);
  45.  
  46. extern PyObject *WinObj_WhichWindow(WindowPtr);
  47.  
  48. #include <Lists.h>
  49.  
  50. static PyObject *List_Error;
  51.  
  52. /* ------------------------ Object type List ------------------------ */
  53.  
  54. PyTypeObject List_Type;
  55.  
  56. #define ListObj_Check(x) ((x)->ob_type == &List_Type)
  57.  
  58. typedef struct ListObject {
  59.     PyObject_HEAD
  60.     ListRef ob_itself;
  61. } ListObject;
  62.  
  63. PyObject *ListObj_New(itself)
  64.     ListRef itself;
  65. {
  66.     ListObject *it;
  67.     if (itself == NULL) {
  68.                         PyErr_SetString(List_Error,"Cannot create null List");
  69.                         return NULL;
  70.                     }
  71.     it = PyObject_NEW(ListObject, &List_Type);
  72.     if (it == NULL) return NULL;
  73.     it->ob_itself = itself;
  74.     return (PyObject *)it;
  75. }
  76. ListObj_Convert(v, p_itself)
  77.     PyObject *v;
  78.     ListRef *p_itself;
  79. {
  80.     if (!ListObj_Check(v))
  81.     {
  82.         PyErr_SetString(PyExc_TypeError, "List required");
  83.         return 0;
  84.     }
  85.     *p_itself = ((ListObject *)v)->ob_itself;
  86.     return 1;
  87. }
  88.  
  89. static void ListObj_dealloc(self)
  90.     ListObject *self;
  91. {
  92.     LDispose(self->ob_itself);
  93.     PyMem_DEL(self);
  94. }
  95.  
  96. static PyObject *ListObj_LAddColumn(_self, _args)
  97.     ListObject *_self;
  98.     PyObject *_args;
  99. {
  100.     PyObject *_res = NULL;
  101.     short _rv;
  102.     short count;
  103.     short colNum;
  104.     if (!PyArg_ParseTuple(_args, "hh",
  105.                           &count,
  106.                           &colNum))
  107.         return NULL;
  108.     _rv = LAddColumn(count,
  109.                      colNum,
  110.                      _self->ob_itself);
  111.     _res = Py_BuildValue("h",
  112.                          _rv);
  113.     return _res;
  114. }
  115.  
  116. static PyObject *ListObj_LAddRow(_self, _args)
  117.     ListObject *_self;
  118.     PyObject *_args;
  119. {
  120.     PyObject *_res = NULL;
  121.     short _rv;
  122.     short count;
  123.     short rowNum;
  124.     if (!PyArg_ParseTuple(_args, "hh",
  125.                           &count,
  126.                           &rowNum))
  127.         return NULL;
  128.     _rv = LAddRow(count,
  129.                   rowNum,
  130.                   _self->ob_itself);
  131.     _res = Py_BuildValue("h",
  132.                          _rv);
  133.     return _res;
  134. }
  135.  
  136. static PyObject *ListObj_LDelColumn(_self, _args)
  137.     ListObject *_self;
  138.     PyObject *_args;
  139. {
  140.     PyObject *_res = NULL;
  141.     short count;
  142.     short colNum;
  143.     if (!PyArg_ParseTuple(_args, "hh",
  144.                           &count,
  145.                           &colNum))
  146.         return NULL;
  147.     LDelColumn(count,
  148.                colNum,
  149.                _self->ob_itself);
  150.     Py_INCREF(Py_None);
  151.     _res = Py_None;
  152.     return _res;
  153. }
  154.  
  155. static PyObject *ListObj_LDelRow(_self, _args)
  156.     ListObject *_self;
  157.     PyObject *_args;
  158. {
  159.     PyObject *_res = NULL;
  160.     short count;
  161.     short rowNum;
  162.     if (!PyArg_ParseTuple(_args, "hh",
  163.                           &count,
  164.                           &rowNum))
  165.         return NULL;
  166.     LDelRow(count,
  167.             rowNum,
  168.             _self->ob_itself);
  169.     Py_INCREF(Py_None);
  170.     _res = Py_None;
  171.     return _res;
  172. }
  173.  
  174. static PyObject *ListObj_LGetSelect(_self, _args)
  175.     ListObject *_self;
  176.     PyObject *_args;
  177. {
  178.     PyObject *_res = NULL;
  179.     Boolean _rv;
  180.     Boolean next;
  181.     Point theCell;
  182.     if (!PyArg_ParseTuple(_args, "bO&",
  183.                           &next,
  184.                           PyMac_GetPoint, &theCell))
  185.         return NULL;
  186.     _rv = LGetSelect(next,
  187.                      &theCell,
  188.                      _self->ob_itself);
  189.     _res = Py_BuildValue("bO&",
  190.                          _rv,
  191.                          PyMac_BuildPoint, theCell);
  192.     return _res;
  193. }
  194.  
  195. static PyObject *ListObj_LLastClick(_self, _args)
  196.     ListObject *_self;
  197.     PyObject *_args;
  198. {
  199.     PyObject *_res = NULL;
  200.     Point _rv;
  201.     if (!PyArg_ParseTuple(_args, ""))
  202.         return NULL;
  203.     _rv = LLastClick(_self->ob_itself);
  204.     _res = Py_BuildValue("O&",
  205.                          PyMac_BuildPoint, _rv);
  206.     return _res;
  207. }
  208.  
  209. static PyObject *ListObj_LNextCell(_self, _args)
  210.     ListObject *_self;
  211.     PyObject *_args;
  212. {
  213.     PyObject *_res = NULL;
  214.     Boolean _rv;
  215.     Boolean hNext;
  216.     Boolean vNext;
  217.     Point theCell;
  218.     if (!PyArg_ParseTuple(_args, "bbO&",
  219.                           &hNext,
  220.                           &vNext,
  221.                           PyMac_GetPoint, &theCell))
  222.         return NULL;
  223.     _rv = LNextCell(hNext,
  224.                     vNext,
  225.                     &theCell,
  226.                     _self->ob_itself);
  227.     _res = Py_BuildValue("bO&",
  228.                          _rv,
  229.                          PyMac_BuildPoint, theCell);
  230.     return _res;
  231. }
  232.  
  233. static PyObject *ListObj_LSize(_self, _args)
  234.     ListObject *_self;
  235.     PyObject *_args;
  236. {
  237.     PyObject *_res = NULL;
  238.     short listWidth;
  239.     short listHeight;
  240.     if (!PyArg_ParseTuple(_args, "hh",
  241.                           &listWidth,
  242.                           &listHeight))
  243.         return NULL;
  244.     LSize(listWidth,
  245.           listHeight,
  246.           _self->ob_itself);
  247.     Py_INCREF(Py_None);
  248.     _res = Py_None;
  249.     return _res;
  250. }
  251.  
  252. static PyObject *ListObj_LSetDrawingMode(_self, _args)
  253.     ListObject *_self;
  254.     PyObject *_args;
  255. {
  256.     PyObject *_res = NULL;
  257.     Boolean drawIt;
  258.     if (!PyArg_ParseTuple(_args, "b",
  259.                           &drawIt))
  260.         return NULL;
  261.     LSetDrawingMode(drawIt,
  262.                     _self->ob_itself);
  263.     Py_INCREF(Py_None);
  264.     _res = Py_None;
  265.     return _res;
  266. }
  267.  
  268. static PyObject *ListObj_LScroll(_self, _args)
  269.     ListObject *_self;
  270.     PyObject *_args;
  271. {
  272.     PyObject *_res = NULL;
  273.     short dCols;
  274.     short dRows;
  275.     if (!PyArg_ParseTuple(_args, "hh",
  276.                           &dCols,
  277.                           &dRows))
  278.         return NULL;
  279.     LScroll(dCols,
  280.             dRows,
  281.             _self->ob_itself);
  282.     Py_INCREF(Py_None);
  283.     _res = Py_None;
  284.     return _res;
  285. }
  286.  
  287. static PyObject *ListObj_LAutoScroll(_self, _args)
  288.     ListObject *_self;
  289.     PyObject *_args;
  290. {
  291.     PyObject *_res = NULL;
  292.     if (!PyArg_ParseTuple(_args, ""))
  293.         return NULL;
  294.     LAutoScroll(_self->ob_itself);
  295.     Py_INCREF(Py_None);
  296.     _res = Py_None;
  297.     return _res;
  298. }
  299.  
  300. static PyObject *ListObj_LUpdate(_self, _args)
  301.     ListObject *_self;
  302.     PyObject *_args;
  303. {
  304.     PyObject *_res = NULL;
  305.     RgnHandle theRgn;
  306.     if (!PyArg_ParseTuple(_args, "O&",
  307.                           ResObj_Convert, &theRgn))
  308.         return NULL;
  309.     LUpdate(theRgn,
  310.             _self->ob_itself);
  311.     Py_INCREF(Py_None);
  312.     _res = Py_None;
  313.     return _res;
  314. }
  315.  
  316. static PyObject *ListObj_LActivate(_self, _args)
  317.     ListObject *_self;
  318.     PyObject *_args;
  319. {
  320.     PyObject *_res = NULL;
  321.     Boolean act;
  322.     if (!PyArg_ParseTuple(_args, "b",
  323.                           &act))
  324.         return NULL;
  325.     LActivate(act,
  326.               _self->ob_itself);
  327.     Py_INCREF(Py_None);
  328.     _res = Py_None;
  329.     return _res;
  330. }
  331.  
  332. static PyObject *ListObj_LCellSize(_self, _args)
  333.     ListObject *_self;
  334.     PyObject *_args;
  335. {
  336.     PyObject *_res = NULL;
  337.     Point cSize;
  338.     if (!PyArg_ParseTuple(_args, "O&",
  339.                           PyMac_GetPoint, &cSize))
  340.         return NULL;
  341.     LCellSize(cSize,
  342.               _self->ob_itself);
  343.     Py_INCREF(Py_None);
  344.     _res = Py_None;
  345.     return _res;
  346. }
  347.  
  348. static PyObject *ListObj_LClick(_self, _args)
  349.     ListObject *_self;
  350.     PyObject *_args;
  351. {
  352.     PyObject *_res = NULL;
  353.     Boolean _rv;
  354.     Point pt;
  355.     short modifiers;
  356.     if (!PyArg_ParseTuple(_args, "O&h",
  357.                           PyMac_GetPoint, &pt,
  358.                           &modifiers))
  359.         return NULL;
  360.     _rv = LClick(pt,
  361.                  modifiers,
  362.                  _self->ob_itself);
  363.     _res = Py_BuildValue("b",
  364.                          _rv);
  365.     return _res;
  366. }
  367.  
  368. static PyObject *ListObj_LAddToCell(_self, _args)
  369.     ListObject *_self;
  370.     PyObject *_args;
  371. {
  372.     PyObject *_res = NULL;
  373.     char *dataPtr__in__;
  374.     short dataPtr__len__;
  375.     int dataPtr__in_len__;
  376.     Point theCell;
  377.     if (!PyArg_ParseTuple(_args, "s#O&",
  378.                           &dataPtr__in__, &dataPtr__in_len__,
  379.                           PyMac_GetPoint, &theCell))
  380.         return NULL;
  381.     dataPtr__len__ = dataPtr__in_len__;
  382.     LAddToCell(dataPtr__in__, dataPtr__len__,
  383.                theCell,
  384.                _self->ob_itself);
  385.     Py_INCREF(Py_None);
  386.     _res = Py_None;
  387.  dataPtr__error__: ;
  388.     return _res;
  389. }
  390.  
  391. static PyObject *ListObj_LClrCell(_self, _args)
  392.     ListObject *_self;
  393.     PyObject *_args;
  394. {
  395.     PyObject *_res = NULL;
  396.     Point theCell;
  397.     if (!PyArg_ParseTuple(_args, "O&",
  398.                           PyMac_GetPoint, &theCell))
  399.         return NULL;
  400.     LClrCell(theCell,
  401.              _self->ob_itself);
  402.     Py_INCREF(Py_None);
  403.     _res = Py_None;
  404.     return _res;
  405. }
  406.  
  407. static PyObject *ListObj_LGetCell(_self, _args)
  408.     ListObject *_self;
  409.     PyObject *_args;
  410. {
  411.     PyObject *_res = NULL;
  412.     char *dataPtr__out__;
  413.     short dataPtr__len__;
  414.     int dataPtr__in_len__;
  415.     Point theCell;
  416.     if (!PyArg_ParseTuple(_args, "iO&",
  417.                           &dataPtr__in_len__,
  418.                           PyMac_GetPoint, &theCell))
  419.         return NULL;
  420.     if ((dataPtr__out__ = malloc(dataPtr__in_len__)) == NULL)
  421.     {
  422.         PyErr_NoMemory();
  423.         goto dataPtr__error__;
  424.     }
  425.     dataPtr__len__ = dataPtr__in_len__;
  426.     LGetCell(dataPtr__out__, &dataPtr__len__,
  427.              theCell,
  428.              _self->ob_itself);
  429.     _res = Py_BuildValue("s#",
  430.                          dataPtr__out__, (int)dataPtr__len__);
  431.     free(dataPtr__out__);
  432.  dataPtr__error__: ;
  433.     return _res;
  434. }
  435.  
  436. static PyObject *ListObj_LRect(_self, _args)
  437.     ListObject *_self;
  438.     PyObject *_args;
  439. {
  440.     PyObject *_res = NULL;
  441.     Rect cellRect;
  442.     Point theCell;
  443.     if (!PyArg_ParseTuple(_args, "O&",
  444.                           PyMac_GetPoint, &theCell))
  445.         return NULL;
  446.     LRect(&cellRect,
  447.           theCell,
  448.           _self->ob_itself);
  449.     _res = Py_BuildValue("O&",
  450.                          PyMac_BuildRect, &cellRect);
  451.     return _res;
  452. }
  453.  
  454. static PyObject *ListObj_LSetCell(_self, _args)
  455.     ListObject *_self;
  456.     PyObject *_args;
  457. {
  458.     PyObject *_res = NULL;
  459.     char *dataPtr__in__;
  460.     short dataPtr__len__;
  461.     int dataPtr__in_len__;
  462.     Point theCell;
  463.     if (!PyArg_ParseTuple(_args, "s#O&",
  464.                           &dataPtr__in__, &dataPtr__in_len__,
  465.                           PyMac_GetPoint, &theCell))
  466.         return NULL;
  467.     dataPtr__len__ = dataPtr__in_len__;
  468.     LSetCell(dataPtr__in__, dataPtr__len__,
  469.              theCell,
  470.              _self->ob_itself);
  471.     Py_INCREF(Py_None);
  472.     _res = Py_None;
  473.  dataPtr__error__: ;
  474.     return _res;
  475. }
  476.  
  477. static PyObject *ListObj_LSetSelect(_self, _args)
  478.     ListObject *_self;
  479.     PyObject *_args;
  480. {
  481.     PyObject *_res = NULL;
  482.     Boolean setIt;
  483.     Point theCell;
  484.     if (!PyArg_ParseTuple(_args, "bO&",
  485.                           &setIt,
  486.                           PyMac_GetPoint, &theCell))
  487.         return NULL;
  488.     LSetSelect(setIt,
  489.                theCell,
  490.                _self->ob_itself);
  491.     Py_INCREF(Py_None);
  492.     _res = Py_None;
  493.     return _res;
  494. }
  495.  
  496. static PyObject *ListObj_LDraw(_self, _args)
  497.     ListObject *_self;
  498.     PyObject *_args;
  499. {
  500.     PyObject *_res = NULL;
  501.     Point theCell;
  502.     if (!PyArg_ParseTuple(_args, "O&",
  503.                           PyMac_GetPoint, &theCell))
  504.         return NULL;
  505.     LDraw(theCell,
  506.           _self->ob_itself);
  507.     Py_INCREF(Py_None);
  508.     _res = Py_None;
  509.     return _res;
  510. }
  511.  
  512. static PyMethodDef ListObj_methods[] = {
  513.     {"LAddColumn", (PyCFunction)ListObj_LAddColumn, 1,
  514.      "(short count, short colNum) -> (short _rv)"},
  515.     {"LAddRow", (PyCFunction)ListObj_LAddRow, 1,
  516.      "(short count, short rowNum) -> (short _rv)"},
  517.     {"LDelColumn", (PyCFunction)ListObj_LDelColumn, 1,
  518.      "(short count, short colNum) -> None"},
  519.     {"LDelRow", (PyCFunction)ListObj_LDelRow, 1,
  520.      "(short count, short rowNum) -> None"},
  521.     {"LGetSelect", (PyCFunction)ListObj_LGetSelect, 1,
  522.      "(Boolean next, Point theCell) -> (Boolean _rv, Point theCell)"},
  523.     {"LLastClick", (PyCFunction)ListObj_LLastClick, 1,
  524.      "() -> (Point _rv)"},
  525.     {"LNextCell", (PyCFunction)ListObj_LNextCell, 1,
  526.      "(Boolean hNext, Boolean vNext, Point theCell) -> (Boolean _rv, Point theCell)"},
  527.     {"LSize", (PyCFunction)ListObj_LSize, 1,
  528.      "(short listWidth, short listHeight) -> None"},
  529.     {"LSetDrawingMode", (PyCFunction)ListObj_LSetDrawingMode, 1,
  530.      "(Boolean drawIt) -> None"},
  531.     {"LScroll", (PyCFunction)ListObj_LScroll, 1,
  532.      "(short dCols, short dRows) -> None"},
  533.     {"LAutoScroll", (PyCFunction)ListObj_LAutoScroll, 1,
  534.      "() -> None"},
  535.     {"LUpdate", (PyCFunction)ListObj_LUpdate, 1,
  536.      "(RgnHandle theRgn) -> None"},
  537.     {"LActivate", (PyCFunction)ListObj_LActivate, 1,
  538.      "(Boolean act) -> None"},
  539.     {"LCellSize", (PyCFunction)ListObj_LCellSize, 1,
  540.      "(Point cSize) -> None"},
  541.     {"LClick", (PyCFunction)ListObj_LClick, 1,
  542.      "(Point pt, short modifiers) -> (Boolean _rv)"},
  543.     {"LAddToCell", (PyCFunction)ListObj_LAddToCell, 1,
  544.      "(Buffer dataPtr, Point theCell) -> None"},
  545.     {"LClrCell", (PyCFunction)ListObj_LClrCell, 1,
  546.      "(Point theCell) -> None"},
  547.     {"LGetCell", (PyCFunction)ListObj_LGetCell, 1,
  548.      "(Buffer dataPtr, Point theCell) -> (Buffer dataPtr)"},
  549.     {"LRect", (PyCFunction)ListObj_LRect, 1,
  550.      "(Point theCell) -> (Rect cellRect)"},
  551.     {"LSetCell", (PyCFunction)ListObj_LSetCell, 1,
  552.      "(Buffer dataPtr, Point theCell) -> None"},
  553.     {"LSetSelect", (PyCFunction)ListObj_LSetSelect, 1,
  554.      "(Boolean setIt, Point theCell) -> None"},
  555.     {"LDraw", (PyCFunction)ListObj_LDraw, 1,
  556.      "(Point theCell) -> None"},
  557.     {NULL, NULL, 0}
  558. };
  559.  
  560. PyMethodChain ListObj_chain = { ListObj_methods, NULL };
  561.  
  562. static PyObject *ListObj_getattr(self, name)
  563.     ListObject *self;
  564.     char *name;
  565. {
  566.     return Py_FindMethodInChain(&ListObj_chain, (PyObject *)self, name);
  567. }
  568.  
  569. #define ListObj_setattr NULL
  570.  
  571. PyTypeObject List_Type = {
  572.     PyObject_HEAD_INIT(&PyType_Type)
  573.     0, /*ob_size*/
  574.     "List", /*tp_name*/
  575.     sizeof(ListObject), /*tp_basicsize*/
  576.     0, /*tp_itemsize*/
  577.     /* methods */
  578.     (destructor) ListObj_dealloc, /*tp_dealloc*/
  579.     0, /*tp_print*/
  580.     (getattrfunc) ListObj_getattr, /*tp_getattr*/
  581.     (setattrfunc) ListObj_setattr, /*tp_setattr*/
  582. };
  583.  
  584. /* ---------------------- End object type List ---------------------- */
  585.  
  586.  
  587. static PyObject *List_LNew(_self, _args)
  588.     PyObject *_self;
  589.     PyObject *_args;
  590. {
  591.     PyObject *_res = NULL;
  592.     ListRef _rv;
  593.     Rect rView;
  594.     Rect dataBounds;
  595.     Point cSize;
  596.     short theProc;
  597.     WindowPtr theWindow;
  598.     Boolean drawIt;
  599.     Boolean hasGrow;
  600.     Boolean scrollHoriz;
  601.     Boolean scrollVert;
  602.     if (!PyArg_ParseTuple(_args, "O&O&O&hO&bbbb",
  603.                           PyMac_GetRect, &rView,
  604.                           PyMac_GetRect, &dataBounds,
  605.                           PyMac_GetPoint, &cSize,
  606.                           &theProc,
  607.                           WinObj_Convert, &theWindow,
  608.                           &drawIt,
  609.                           &hasGrow,
  610.                           &scrollHoriz,
  611.                           &scrollVert))
  612.         return NULL;
  613.     _rv = LNew(&rView,
  614.                &dataBounds,
  615.                cSize,
  616.                theProc,
  617.                theWindow,
  618.                drawIt,
  619.                hasGrow,
  620.                scrollHoriz,
  621.                scrollVert);
  622.     _res = Py_BuildValue("O&",
  623.                          ListObj_New, _rv);
  624.     return _res;
  625. }
  626.  
  627. static PyMethodDef List_methods[] = {
  628.     {"LNew", (PyCFunction)List_LNew, 1,
  629.      "(Rect rView, Rect dataBounds, Point cSize, short theProc, WindowPtr theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert) -> (ListRef _rv)"},
  630.     {NULL, NULL, 0}
  631. };
  632.  
  633.  
  634.  
  635.  
  636. void initList()
  637. {
  638.     PyObject *m;
  639.     PyObject *d;
  640.  
  641.  
  642.  
  643.  
  644.     m = Py_InitModule("List", List_methods);
  645.     d = PyModule_GetDict(m);
  646.     List_Error = PyMac_GetOSErrException();
  647.     if (List_Error == NULL ||
  648.         PyDict_SetItemString(d, "Error", List_Error) != 0)
  649.         Py_FatalError("can't initialize List.Error");
  650. }
  651.  
  652. /* ======================== End module List ========================= */
  653.  
  654.